
#include <assert.h>
#include "cmd_obj.h"
#include "cooperatordao_stub4app.h"
#include "cooperatordao_req_resp.h"


using namespace b2b2c::cooperator::dao;

	
	uint32_t CCooperatorDaoStub4App::CheckCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorPassword,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoCheckCooperatorPassWdReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.cooperatorPassword = cooperatorPassword;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoCheckCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendCheckCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorPassword,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoCheckCooperatorPassWdReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.cooperatorPassword = cooperatorPassword;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvCheckCooperatorPassWd(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoCheckCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvCheckCooperatorPassWd(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoCheckCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetCheckCooperatorPassWdRespCmd(
	)
	{	    
	    return COOPERATORDAO_CHECKCOOPERATORPASSWD_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::DeleteCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoDeleteCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.modelId = modelId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoDeleteCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendDeleteCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoDeleteCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.modelId = modelId;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvDeleteCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoDeleteCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvDeleteCooperatorMonitorModel(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoDeleteCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetDeleteCooperatorMonitorModelRespCmd(
	)
	{	    
	    return COOPERATORDAO_DELETECOOPERATORMONITORMODEL_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::GetCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				std::string& outReserve
	)
	{
	    CCooperatorDaoGetCooperatorBaseInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.cooperatorBaseInfoDdo = cooperatorBaseInfoDdo;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			cooperatorBaseInfoDdo  = oResp.cooperatorBaseInfoDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendGetCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoGetCooperatorBaseInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			cooperatorBaseInfoDdo  = oResp.cooperatorBaseInfoDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorBaseInfo(
				CCmdObj& rCmd,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			cooperatorBaseInfoDdo  = oResp.cooperatorBaseInfoDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetGetCooperatorBaseInfoRespCmd(
	)
	{	    
	    return COOPERATORDAO_GETCOOPERATORBASEINFO_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::GetCooperatorKey(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& sCooperatorKey,
				std::string& outReserve
	)
	{
	    CCooperatorDaoGetCooperatorKeyReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.sCooperatorKey = sCooperatorKey;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorKeyResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			sCooperatorKey  = oResp.sCooperatorKey;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendGetCooperatorKey(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoGetCooperatorKeyReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorKey(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& sCooperatorKey,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorKeyResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			sCooperatorKey  = oResp.sCooperatorKey;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorKey(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& sCooperatorKey,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorKeyResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			sCooperatorKey  = oResp.sCooperatorKey;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetGetCooperatorKeyRespCmd(
	)
	{	    
	    return COOPERATORDAO_GETCOOPERATORKEY_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::GetCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::set<uint8_t >& licenseType,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo >& cooperatorLicenseDdo,
				std::string& outReserve
	)
	{
	    CCooperatorDaoGetCooperatorLicenseReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.licenseType = licenseType;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.cooperatorLicenseDdo = cooperatorLicenseDdo;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			cooperatorLicenseDdo  = oResp.cooperatorLicenseDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendGetCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::set<uint8_t >& licenseType,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoGetCooperatorLicenseReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.licenseType = licenseType;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorLicense(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo >& cooperatorLicenseDdo,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			cooperatorLicenseDdo  = oResp.cooperatorLicenseDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorLicense(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorLicenseDdo >& cooperatorLicenseDdo,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			cooperatorLicenseDdo  = oResp.cooperatorLicenseDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetGetCooperatorLicenseRespCmd(
	)
	{	    
	    return COOPERATORDAO_GETCOOPERATORLICENSE_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::GetCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{
	    CCooperatorDaoGetCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.modelId = modelId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendGetCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				uint32_t modelId,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoGetCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.modelId = modelId;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorMonitorModel(
				CCmdObj& rCmd,
				std::string& errmsg,
				b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetGetCooperatorMonitorModelRespCmd(
	)
	{	    
	    return COOPERATORDAO_GETCOOPERATORMONITORMODEL_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::GetCooperatorMonitorModelList(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo >& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{
	    CCooperatorDaoGetCooperatorMonitorModelListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorMonitorModelListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendGetCooperatorMonitorModelList(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t cooperatorId,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoGetCooperatorMonitorModelListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorMonitorModelList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo >& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorMonitorModelListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvGetCooperatorMonitorModelList(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo >& CooperatorMonitorModelDdo,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoGetCooperatorMonitorModelListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			CooperatorMonitorModelDdo  = oResp.CooperatorMonitorModelDdo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetGetCooperatorMonitorModelListRespCmd(
	)
	{	    
	    return COOPERATORDAO_GETCOOPERATORMONITORMODELLIST_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::SetCooperatorInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorSetDdo& cooperatorSetDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoSetCooperatorInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.cooperatorSetDdo = cooperatorSetDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendSetCooperatorInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorSetDdo& cooperatorSetDdo,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoSetCooperatorInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.cooperatorSetDdo = cooperatorSetDdo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvSetCooperatorInfo(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvSetCooperatorInfo(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetSetCooperatorInfoRespCmd(
	)
	{	    
	    return COOPERATORDAO_SETCOOPERATORINFO_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::SetCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorOldPassword,
				const std::string& cooperatorNewPassword,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoSetCooperatorPassWdReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.cooperatorOldPassword = cooperatorOldPassword;
			oReq.cooperatorNewPassword = cooperatorNewPassword;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendSetCooperatorPassWd(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t cooperatorId,
				const std::string& cooperatorOldPassword,
				const std::string& cooperatorNewPassword,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoSetCooperatorPassWdReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorId = cooperatorId;
			oReq.cooperatorOldPassword = cooperatorOldPassword;
			oReq.cooperatorNewPassword = cooperatorNewPassword;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvSetCooperatorPassWd(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvSetCooperatorPassWd(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorPassWdResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetSetCooperatorPassWdRespCmd(
	)
	{	    
	    return COOPERATORDAO_SETCOOPERATORPASSWD_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::SetCooperatorPro(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorProDdo& cooperatorProDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoSetCooperatorProReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.cooperatorProDdo = cooperatorProDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorProResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendSetCooperatorPro(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t option,
				const b2b2c::cooperator::ddo::CCooperatorProDdo& cooperatorProDdo,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoSetCooperatorProReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.cooperatorProDdo = cooperatorProDdo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvSetCooperatorPro(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorProResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvSetCooperatorPro(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoSetCooperatorProResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetSetCooperatorProRespCmd(
	)
	{	    
	    return COOPERATORDAO_SETCOOPERATORPRO_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::UpdateCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoUpdateCooperatorBaseInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorBaseInfoDdo = cooperatorBaseInfoDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendUpdateCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorBaseInfoDdo& cooperatorBaseInfoDdo,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoUpdateCooperatorBaseInfoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorBaseInfoDdo = cooperatorBaseInfoDdo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvUpdateCooperatorBaseInfo(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvUpdateCooperatorBaseInfo(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorBaseInfoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetUpdateCooperatorBaseInfoRespCmd(
	)
	{	    
	    return COOPERATORDAO_UPDATECOOPERATORBASEINFO_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::UpdateCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorLicenseDdo& cooperatorLicenseDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoUpdateCooperatorLicenseReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorLicenseDdo = cooperatorLicenseDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendUpdateCooperatorLicense(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorLicenseDdo& cooperatorLicenseDdo,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoUpdateCooperatorLicenseReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.cooperatorLicenseDdo = cooperatorLicenseDdo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvUpdateCooperatorLicense(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvUpdateCooperatorLicense(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorLicenseResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetUpdateCooperatorLicenseRespCmd(
	)
	{	    
	    return COOPERATORDAO_UPDATECOOPERATORLICENSE_RESP_CMD_ID;
	}	
	
	uint32_t CCooperatorDaoStub4App::UpdateCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
	    CCooperatorDaoUpdateCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
	
	    if(m_pSvcCntl->schedule() != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	uint32_t CCooperatorDaoStub4App::SendUpdateCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,

				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const b2b2c::cooperator::ddo::CCooperatorMonitorModelDdo& CooperatorMonitorModelDdo,
				const std::string& inReserve
	)
	{
	    CCooperatorDaoUpdateCooperatorMonitorModelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.CooperatorMonitorModelDdo = CooperatorMonitorModelDdo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if(m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey()) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return 0xFFF1;
	    }
		return 0;
	}
	uint32_t CCooperatorDaoStub4App::RecvUpdateCooperatorMonitorModel(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID))
	    {
	        m_sErrMsg = "Cmd not match for COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID";
	        return 0xFFF3;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::RecvUpdateCooperatorMonitorModel(
				CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CCooperatorDaoUpdateCooperatorMonitorModelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xFFF4;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	uint32_t CCooperatorDaoStub4App::GetUpdateCooperatorMonitorModelRespCmd(
	)
	{	    
	    return COOPERATORDAO_UPDATECOOPERATORMONITORMODEL_RESP_CMD_ID;
	}	
